/* c_screen.cpp -- console screen driver

   This file is part of the UPX executable compressor.

   Copyright (C) 1996-2023 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1996-2023 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
   and/or modify them under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Markus F.X.J. Oberhumer              Laszlo Molnar
   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */

#include "../conf.h"

#if (USE_SCREEN)

#include "screen.h"

#define mask_fg 0x0f
#define mask_bg 0xf0

/*************************************************************************
//
**************************************************************************/

static int do_init(screen_t *s, int fd) {
    int fg, bg;

    if (s->init(s, fd) != 0)
        return -1;

    if (s->getCols(s) < 80 || s->getCols(s) > 256)
        return -1;
    if (s->getRows(s) < 24)
        return -1;

    fg = s->getFg(s);
    bg = s->getBg(s);
    if (s->isMono(s))
        fg = -1;
    if (fg == (bg >> 4))
        return -1;
    if (bg != BG_BLACK)
        if (!s->isMono(s)) {
            /* return 0; */ /* we could emulate ANSI mono */
            return -1;
        }

    return 0;
}

static screen_t *do_construct(screen_t *s, int fd) {
    if (!s)
        return nullptr;
    if (do_init(s, fd) != 0) {
        s->destroy(s);
        return nullptr;
    }
    return s;
}

/*************************************************************************
//
**************************************************************************/

static screen_t *screen = nullptr;

static void __acc_cdecl_atexit do_destroy(void) {
    if (screen) {
        if (screen->atExit)
            screen->atExit();
        screen->destroy(screen);
        screen = nullptr;
    }
}

static int mode = -1;
static int init_fg = -1;
static int init_bg = -1;
static int cur_fg = -1;
static int cur_bg = -1;

static int init(FILE *f, int o, int now) {
    int fd = fileno(f);
    int n;

    UNUSED(now);
    assert(screen == nullptr);

    if (o == CON_SCREEN)
        n = CON_SCREEN;
    else if (o == CON_INIT) /* use by default */
        n = CON_SCREEN;
    else if (o == CON_ANSI_COLOR) /* can emulate ANSI color */
        n = CON_ANSI_COLOR;
    else if (o == CON_ANSI_MONO) /* can emulate ANSI mono */
        n = CON_ANSI_MONO;
    else
        return CON_INIT;

#if (ACC_OS_DOS32) && defined(__DJGPP__)
    if (!screen)
        screen = do_construct(screen_djgpp2_construct(), fd);
#endif
#if (USE_SCREEN_WIN32)
    if (!screen)
        screen = do_construct(screen_win32_construct(), fd);
#endif
#if (USE_SCREEN_VCSA)
    if (!screen)
        screen = do_construct(screen_vcsa_construct(), fd);
#endif
#if (USE_SCREEN_CURSES)
    if (!screen && o == CON_SCREEN)
        screen = do_construct(screen_curses_construct(), fd);
#endif
    if (!screen)
        return CON_INIT;

    mode = screen->getMode(screen);
    init_fg = cur_fg = screen->getFg(screen);
    init_bg = cur_bg = screen->getBg(screen);
    if (screen->isMono(screen))
        cur_fg = -1;

    atexit(do_destroy);
    return n;
}

static int set_fg(FILE *f, int fg) {
    const int last_fg = cur_fg;
    int f1 = fg & mask_fg;
    int f2 = init_fg & mask_fg;

    UNUSED(f);
    cur_fg = fg;
    if (screen->isMono(screen)) {
        const int b = (init_bg & mask_bg) >> 4;
        if (fg == -1) /* restore startup fg */
            f1 = f2;
        else if (b == 0)
            f1 = (f2 <= 8) ? 15 : 8;
        else if (b <= 8)
            f1 = (f2 == 0) ? 15 : 0;
        else
            f1 = (f2 == 0) ? 8 : 0;
    } else if (con_mode == CON_ANSI_MONO && f1 != f2) {
        f1 = f2 ^ 0x08;
    }

    screen->setFg(screen, f1 & mask_fg);
    return last_fg;
}

static void print0(FILE *f, const char *ss) {
    int cx, cy;
    int old_cx = 0, old_cy = 0;
    const int sx = screen->getCols(screen);
    const int sy = screen->getRows(screen);
    int pass;

    // Note:
    //   We use 2 passes to avoid unnecessary system calls because
    //   scrollUp() under Win32 is *extremely* slow.
    UNUSED(f);

    screen->getCursor(screen, &old_cx, &old_cy);
    cx = old_cx;
    cy = old_cy;

    for (pass = 0; pass < 2; pass++) {
        const char *s = ss;
        // char buffer for pass 2
        char p[256 + 1];
        int pi = 0, px = 0, py = 0;

        for (;;) {
            // walk over whitespace
            for (;;) {
                if (*s == '\n') {
                    cx = 0;
                    cy++;
                } else if (*s == '\r') {
                    cx = 0;
                    if (pass > 0 && cy < sy)
                        screen->clearLine(screen, cy);
                } else
                    break;
                s++;
            }
            // adjust cursor
            if (cx >= sx) {
                cx = 0;
                cy++;
            }
            if (pass > 0) {
                // check if we should print something
                if (pi > 0 && (*s == 0 || py != cy)) {
                    p[pi] = 0;
                    screen->putString(screen, p, px, py);
                    pi = 0;
                }
                // check if we should scroll even more (this can happen
                // if the string is longer than sy lines)
                if (cy >= sy) {
                    int scroll_y = cy - sy + 1;
                    screen->scrollUp(screen, scroll_y);
                    cy -= scroll_y;
                    if (cy < 0)
                        cy = 0;
                }
            }
            // done ?
            if (*s == 0)
                break;
            if (pass > 0) {
                // store current char
                if (pi == 0) {
                    px = cx;
                    py = cy;
                }
                p[pi++] = *s;
            }
            // advance
            cx++;
            s++;
        }

        if (pass == 0) {
            // end of pass 1 - scroll up, restore cursor
            if (cy >= sy) {
                int scroll_y = cy - sy + 1;
                screen->scrollUp(screen, scroll_y);
                cy = old_cy - scroll_y;
                if (cy < 0)
                    cy = 0;
            } else
                cy = old_cy;
            cx = old_cx;
        }
    }

    screen->setCursor(screen, cx, cy);
    screen->refresh(screen);
}

static bool intro(FILE *f) {
    UNUSED(f);
#if (USE_FRAMES)
    if (screen->intro)
        return screen->intro(screen, screen_show_frames);
#endif
    return 0;
}

console_t console_screen = {init, set_fg, print0, intro};

#endif /* USE_SCREEN */

/* vim:set ts=4 sw=4 et: */
